import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import 'package:shared_preferences/shared_preferences.dart';

/// 本地存储服务 - 基础设施层/工具类
/// 负责应用的键值对存储，基于 SharedPreferences
/// 
/// 🎯 核心职责：
/// - 提供纯粹的 key-value 存储能力
/// - 缓存 SharedPreferences 实例
/// - 统一错误处理和日志记录
/// - 支持基本数据类型和 JSON 序列化
/// 
/// ⚠️ 重要原则：
/// - 纯工具类，只负责存储操作
/// - 不包含任何业务逻辑
/// - 不维护任何业务状态
/// - 不直接接触业务常量
/// - 业务逻辑应该在对应的业务服务中处理（如 AppConfigService、UserService 等）
class StorageService extends GetxService {
  static StorageService get to => Get.find<StorageService>();
  
  late SharedPreferences _prefs;
  
  // 响应式变量 - 仅用于标记初始化状态
  final _isInitialized = false.obs;
  
  // Getters
  bool get isInitialized => _isInitialized.value;
  RxBool get isInitializedRx => _isInitialized;
  
  @override
  Future<void> onInit() async {
    super.onInit();
    debugPrint('🔧 StorageService 初始化开始...');
    
    try {
      await _initSharedPreferences();
      _isInitialized.value = true;
      
      debugPrint('✅ StorageService 初始化完成');
    } catch (e) {
      debugPrint('❌ StorageService 初始化失败: $e');
      rethrow;
    }
  }
  
  /// 初始化 SharedPreferences
  Future<void> _initSharedPreferences() async {
    try {
      _prefs = await SharedPreferences.getInstance();
      debugPrint('📦 SharedPreferences 实例获取成功');
    } catch (e) {
      debugPrint('❌ SharedPreferences 初始化失败: $e');
      rethrow;
    }
  }
  
  // ==================== 通用存储方法 ====================
  
  /// 通用字符串存储
  Future<bool> setString(String key, String value) async {
    try {
      return await _prefs.setString(key, value);
    } catch (e) {
      debugPrint('❌ 存储字符串失败 [$key]: $e');
      return false;
    }
  }
  
  /// 通用字符串读取
  String? getString(String key, {String? defaultValue}) {
    try {
      // 先检查键是否存在
      if (!_prefs.containsKey(key)) {
        return defaultValue;
      }
      
      // 安全获取值，避免类型转换错误
      final value = _prefs.get(key);
      if (value is String) {
        return value.isNotEmpty ? value : defaultValue;
      }
      
      // 如果不是字符串类型，返回默认值
      return defaultValue;
    } catch (e) {
      debugPrint('❌ 读取字符串失败 [$key]: $e');
      return defaultValue;
    }
  }
  
  /// 通用布尔值存储
  Future<bool> setBool(String key, bool value) async {
    try {
      return await _prefs.setBool(key, value);
    } catch (e) {
      debugPrint('❌ 存储布尔值失败 [$key]: $e');
      return false;
    }
  }
  
  /// 通用布尔值读取
  bool? getBool(String key, {bool? defaultValue}) {
    try {
      // 先检查键是否存在
      if (!_prefs.containsKey(key)) {
        return defaultValue;
      }
      
      // 安全获取值，避免类型转换错误
      final value = _prefs.get(key);
      if (value is bool) {
        return value;
      }
      
      // 如果不是布尔类型，返回默认值
      return defaultValue;
    } catch (e) {
      debugPrint('❌ 读取布尔值失败 [$key]: $e');
      return defaultValue;
    }
  }
  
  /// 通用整数存储
  Future<bool> setInt(String key, int value) async {
    try {
      return await _prefs.setInt(key, value);
    } catch (e) {
      debugPrint('❌ 存储整数失败 [$key]: $e');
      return false;
    }
  }
  
  /// 通用整数读取
  int? getInt(String key, {int? defaultValue}) {
    try {
      // 先检查键是否存在
      if (!_prefs.containsKey(key)) {
        return defaultValue;
      }
      
      // 安全获取值，避免类型转换错误
      final value = _prefs.get(key);
      if (value is int) {
        return value;
      }
      
      // 如果不是整数类型，返回默认值
      return defaultValue;
    } catch (e) {
      debugPrint('❌ 读取整数失败 [$key]: $e');
      return defaultValue;
    }
  }
  
  /// 通用对象存储（JSON序列化）
  Future<bool> setObject(String key, Map<String, dynamic> value) async {
    try {
      final jsonString = jsonEncode(value);
      return await _prefs.setString(key, jsonString);
    } catch (e) {
      debugPrint('❌ 存储对象失败 [$key]: $e');
      return false;
    }
  }
  
  /// 通用对象读取（JSON反序列化）
  Map<String, dynamic>? getObject(String key) {
    try {
      final jsonString = _prefs.getString(key);
      if (jsonString != null && jsonString.isNotEmpty) {
        return jsonDecode(jsonString) as Map<String, dynamic>;
      }
      return null;
    } catch (e) {
      debugPrint('❌ 读取对象失败 [$key]: $e');
      return null;
    }
  }
  
  /// 检查键是否存在
  bool containsKey(String key) {
    return _prefs.containsKey(key);
  }
  
  /// 删除指定键
  Future<bool> remove(String key) async {
    try {
      return await _prefs.remove(key);
    } catch (e) {
      debugPrint('❌ 删除键失败 [$key]: $e');
      return false;
    }
  }
  
  /// 清空所有数据
  Future<bool> clear() async {
    try {
      debugPrint('🧹 清空所有存储数据...');
      await _prefs.clear();
      debugPrint('✅ 所有存储数据已清空');
      return true;
    } catch (e) {
      debugPrint('❌ 清空存储数据失败: $e');
      return false;
    }
  }
  
  /// 获取所有键
  Set<String> getAllKeys() {
    return _prefs.getKeys();
  }
  
  /// 获取存储值的实际类型
  String getValueType(String key) {
    try {
      if (!_prefs.containsKey(key)) {
        return 'NotFound';
      }
      
      final value = _prefs.get(key);
      if (value is bool) {
        return 'Bool';
      } else if (value is int) {
        return 'Int';
      } else if (value is double) {
        return 'Double';
      } else if (value is String) {
        // 检查是否是JSON格式的字符串
        if (_looksLikeJson(value)) {
          return 'Object';
        }
        return 'String';
      } else if (value is List<String>) {
        return 'StringList';
      }
      
      return 'Unknown';
    } catch (e) {
      debugPrint('❌ 获取值类型失败 [$key]: $e');
      return 'Unknown';
    }
  }
  
  /// 检查字符串是否看起来像JSON
  bool _looksLikeJson(String value) {
    final trimmed = value.trim();
    return (trimmed.startsWith('{') && trimmed.endsWith('}')) ||
           (trimmed.startsWith('[') && trimmed.endsWith(']'));
  }
  
  /// 重新加载数据
  Future<void> reload() async {
    try {
      debugPrint('🔄 重新加载存储数据...');
      await _prefs.reload();
      debugPrint('✅ 存储数据重新加载完成');
    } catch (e) {
      debugPrint('❌ 重新加载存储数据失败: $e');
    }
  }
  
  @override
  void onClose() {
    debugPrint('🧹 StorageService 正在清理...');
    super.onClose();
  }
}
